package gamesession

/*
全局会话管理器
*/

import (
	"sync"
	"time"

	"gameServer/eventbus"
)

var (
	globalManager *SessionManager
	once          sync.Once
)

// SessionManagerInterface 定义会话管理器接口
// type SessionManagerInterface interface {
// 	CreateSession(config SessionConfig) (GameSession, error)
// 	GetSession(sessionID string) (GameSession, error)
// 	RemoveSession(sessionID string) error
// 	FindAvailableSession() (GameSession, error)
// 	GetAllSessions() ([]GameSession, error)
// 	AddPlayerToSession(sessionID, playerID string) error
// 	RemovePlayerFromSession(sessionID, playerID string) error
// 	GetStats() SessionStats
// 	StopMonitor()
// }

// // 修改GlobalManager，返回增强的接口
// type SessionManagerWithAdmin interface {
// 	SessionManagerInterface
// 	GetStats() SessionStats
// 	StopMonitor()
// }

// // 确保全局管理器实现新接口
// var _ SessionManagerWithAdmin = (*SessionManager)(nil)

// // GlobalManagerWithAdmin 获取支持管理功能的全局管理器
// func GlobalManagerWithAdmin() SessionManagerWithAdmin {
// 	return GlobalManager()
// }

// 修改 global.go 中的 GlobalManager 函数
func GlobalManager() *SessionManager {
	once.Do(func() {
		// var storage SessionStorage
		// var config ManagerConfig

		// 统一配置
		config := ManagerConfig{
			MaxSessions:     1000,
			CleanupInterval: 60 * time.Second,
			SessionTimeout:  10 * time.Minute,
		}

		// // 获取Redis数据库实例
		// db, err := database.GlobalManager().GetDatabase("session_redis")
		// if err != nil {
		// 	// 使用默认的内存存储作为fallback
		// 	log.Infof("Using memory storage as fallback: %v", err)
		// 	storage = NewMemoryStorage()
		// } else {
		// 	redisDB, ok := db.(*database.RedisDatabase)
		// 	if !ok {
		// 		// 使用默认的内存存储作为fallback
		// 		log.Info("Session database is not Redis type, using memory storage")
		// 		storage = NewMemoryStorage()
		// 	} else {
		// 		// 使用Redis存储
		// 		log.Info("Using Redis storage for sessions")
		// 		storage = NewRedisStorage(redisDB)
		// 	}
		// }

		// 创建管理器 (不传入storage参数)
		globalManager = NewSessionManager(eventbus.GlobalEventBus(), config)

		// // 恢复存储的会话（所有存储类型都需要）
		// if err := globalManager.RestoreSessions(); err != nil {
		// 	log.Infof("Failed to restore sessions: %v", err)
		// } else {
		// 	log.Info("Session restoration completed")
		// }
	})
	return globalManager
}

// // 添加内存存储作为fallback
// type MemoryStorage struct {
// 	data map[string][]byte
// 	mu   sync.RWMutex
// }
//
// func NewMemoryStorage() SessionStorage {
// 	return &MemoryStorage{
// 		data: make(map[string][]byte),
// 	}
// }
//
// func (ms *MemoryStorage) SaveSession(sessionID string, data []byte, expiration time.Duration) error {
// 	ms.mu.Lock()
// 	defer ms.mu.Unlock()
// 	ms.data[sessionID] = data
// 	return nil
// }
//
// func (ms *MemoryStorage) LoadSession(sessionID string) ([]byte, error) {
// 	ms.mu.RLock()
// 	defer ms.mu.RUnlock()
// 	data, exists := ms.data[sessionID]
// 	if !exists {
// 		return nil, errors.New("session not found")
// 	}
// 	return data, nil
// }
//
// func (ms *MemoryStorage) DeleteSession(sessionID string) error {
// 	ms.mu.Lock()
// 	defer ms.mu.Unlock()
// 	delete(ms.data, sessionID)
// 	return nil
// }
//
// func (ms *MemoryStorage) SessionExists(sessionID string) (bool, error) {
// 	ms.mu.RLock()
// 	defer ms.mu.RUnlock()
// 	_, exists := ms.data[sessionID]
// 	return exists, nil
// }

// CreateSession 全局创建会话
func CreateSession(config SessionConfig) (GameSession, error) {
	return GlobalManager().CreateSession(config)
}

// GetSession 全局获取会话
func GetSession(sessionID string) (GameSession, error) {
	return GlobalManager().GetSession(sessionID)
}

// AddPlayerToSession 全局添加玩家到会话
func AddPlayerToSession(sessionID, playerID string) error {
	return GlobalManager().AddPlayerToSession(sessionID, playerID)
}

// RemovePlayerFromSession 全局从会话移除玩家
func RemovePlayerFromSession(sessionID, playerID string) error {
	return GlobalManager().RemovePlayerFromSession(sessionID, playerID)
}
